package com.test;

/*
//定义Animal类
class Animal {
    public final String COLOR = "白色"; //定义COLOR属性
    private String name;    //声明name属性
    private int age;        //声明age属性

    public String getName() {        //定义name属性的getter方法
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//定义Dog类继承Animal类
class Dog extends Animal {
    //此处不写代码
}

//定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();  //创建一个Dog类的对象
        dog.setName("萨摩耶");
        dog.setAge(3);
        System.out.println("名称：" + dog.getName() + ",年龄：" + dog.getAge() + ",颜色：" + dog.COLOR);
    }
}


 */


/*
// 定义Animal类
class Animal {
    private String name;         		// 声明name属性
    private int age;             		// 声明age属性
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    private String color;        // 声明color属性
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();     // 创建并实例化dog对象
        dog.setName("牧羊犬");    // 此时访问的是父类Animal中的setter方法
        dog.setAge(3);           // 此时访问的是父类Animal中的setter方法
        dog.setColor("黑色");     // 此时访问的是Dog类中的setter方法
        System.out.println("名称："+dog.getName()+",年龄："+dog.getAge()+ ",颜色："+dog.getColor());
    }
}

 */

/*
// 定义Animal类
class Animal {
    //定义动物叫的方法
    void shout() {
        System.out.println("动物发出叫声");
    }
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    //重写父类Animal中的shout()方法
    void shout() {
        System.out.println("汪汪汪……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();    // 创建Dog类的实例对象
        dog.shout();            // 调用Dog类重写的shout()方法
    }
}

 */

/*
// 定义Animal类
class Animal {
    //定义动物叫的方法
    public void shout() {
        System.out.println("动物发出叫声");
    }
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    //重写父类Animal中的shout()方法
    private void shout() {
        System.out.println("汪汪汪……");
    }
}
public class Example04 {
    public static void main(String[] args) {
        Dog dog = new Dog();    // 创建Dog类的实例对象
        dog.shout();            // 调用Dog类重写的shout()方法
    }
}
//'com.test.Dog' 中的 'shout（）' 与 'com.test.Animal' 中的 'shout（）' 冲突;试图分配较弱的访问权限（“私有”）;是“公开的”

 */

/*
class Animal{
    String name="牧羊犬";
    //定义动物发出叫声的方法
    void shout(){
        System.out.println("动物发出叫声");
    }
}

class Dog extends Animal{
    //重写父类Animal中的shout()方法,扩大了访问权限
    public void shout(){
        super.shout();
        System.out.println("汪汪汪");

    }
    public void printName(){
        System.out.println("名字:"+super.name);   //访问父类中的name方法
    }
}
public class Summary01 {
    public static void main(String[] args){
        Dog dog = new Dog();
        dog.shout();
        dog.printName();
    }
}

 */

/*
class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String info() {
        return "名称:" + this.getName() + ",年龄:" + this.getAge();
    }
}

//定义Dog类继承Animal类
class Dog extends Animal {
    private String color;
    public Dog(String name, int age, String color) {
        super(name, age);
        this.setColor(color);
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    //重写父类info()方法
    public String info(){
        return super.info()+",颜色:"+this.getColor();     //扩充父类中的方法
    }
}

public class Summary01 {
    public static  void main(String[] args){
        Dog dog = new Dog("牧羊犬",2,"灰色");
//        dog.info();
        System.out.println(dog.info());
    }
}

 */

/*
// 使用final关键字修饰Animal类
final class Animal {
}
// Dog类继承Animal类
class Dog extends Animal {
}
//Cannot inherit from final 'com.test.Animal'
//无法继承最终的“com.test.Animal
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog(); 		// 创建Dog类的对象
    }
}


 */


/*
// 定义Animal类
class Animal {
    // 使用final关键字修饰shout()方法
    public final void shout() {}
}
// 定义Dog类继承Animal类
class Dog extends Animal {
    // 重写Animal类的shout()方法
    public void shout() {}
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog=new Dog(); // 创建Dog类的对象
    }
}

 */

/*
public class Summary01 {
    public static void main(String[] args) {
        final int AGE = 18;      // 使用final关键字修饰的变量AGE第一次可以被赋值
        AGE = 20;                // 再次被赋值会报错
    }
}

 */

/*
//定义抽象类Animal
abstract class Animal {
    //定义抽象方法shout()
    abstract  void shout();
}

//定义Dog类继承抽象类Animal
class Dog extends Animal {
    //实现抽象方法shout()
    void shout() {
        System.out.println("汪汪");
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}

 */

/*
//定义接口Animal
interface Animal {
    int ID = 1;         // 定全局常量,编号
    String NAME = "牧羊犬";

    static int getID() {    // 定义静态方法getID(),用于返回ID值
        return Animal.ID;
    }

    void shout();   // 定义抽象方法shout()

    public void info();     // 定义抽象方法info()
}

interface Action {
    public void eat();      //定义抽象方法eat()
}

class Dog implements Animal, Action {
    //实现Action接口中的抽象方法eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }

    //实现Animal接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args){
        System.out.println("编号:"+Animal.getID());
        Dog dog=new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}

 */

/*
//定义接口Animal
interface Animal {
    public String NAME = "牧羊犬";

    public void shout();   // 定义抽象方法shout()

    public void info();     // 定义抽象方法info()
}

abstract class Action {
    public abstract void eat();
}

class Dog extends Action implements Animal {
    //实现Action接口中的抽象方法eat()
    public void eat() {
        System.out.println("喜欢吃骨头");
    }

    //实现Animal接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.eat();
    }
}


 */


/*
//定义接口Animal
interface Animal {
    public String NAME = "牧羊犬";

    public void info();     // 定义抽象方法info()
}

interface Color {
    public void black();    //定义抽象接口black()
}

//定义接口Action,Action同时继承接口Animal和接口Color
interface Action extends Animal,Color{
    public void shout();    //定义抽象方法shout()
}

class Dog implements Action {
    //实现Color接口中的抽象方法black()
    public void black(){
        System.out.println("黑色");
    }

    //实现Action接口中的抽象方法shout()
    public void shout() {
        System.out.println("汪汪");
    }

    //实现Animal接口中的抽象方法info()
    public void info() {
        System.out.println("名称:" + NAME);
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.info();
        dog.shout();
        dog.black();
    }
}

 */

/*
// 定义抽象类Animal
abstract class Animal {
    abstract void shout();     	// 定义抽象shout()方法
}
//// 定义Cat类继承Animal抽象类
class Cat extends Animal {
    // 实现shout()方法
    public void shout() {
        System.out.println("喵喵……");
    }
}
//// 定义Dog类继承Animal抽象类
class Dog extends Animal {
    // 实现shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
}
// 定义测试类
public class Summary01{
    public static void main(String[] args) {
        Animal an1 = new Cat(); // 创建Cat对象,使用Animal类型的变量an1引用
        Animal an2 = new Dog(); // 创建Dog对象,使用Animal类型的变量an2引用
        an1.shout();
        an2.shout();
    }
}

 */

/*
class Animal {
    public void shout(){
        System.out.println("喵喵……");
    }
}
//// 定义Dog类
class Dog extends Animal {
    // 重写shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
    public void eat() {
        System.out.println("吃骨头……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Dog dog = new Dog();  // 创建Dog对象
        Animal an = dog;		// 向上转型
        an.shout();
    }
}


 */

/*
// 定义Animal类
class Animal {
    public void shout(){
        System.out.println("喵喵……");
    }
}
// 定义Dog类
class Dog extends Animal {
    // 重写shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }
    public void eat() {
        System.out.println("吃骨头……");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal an = new Dog();  // 此时发生了向上转型，子类→父类
        Dog dog = (Dog)an;       // 此时发生了向下转型
        dog.shout();
        dog.eat();
    }
}

 */

/*
// 定义Animal类
class Animal {
    public void shout() {
        System.out.println("动物叫……");
    }
}

// 定义Dog类
class Dog extends Animal {
    // 重写shout()方法
    public void shout() {
        System.out.println("汪汪……");
    }

    public void eat() {
        System.out.println("吃骨头……");
    }
}

// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal a1 = new Dog();         // 通过向上转型实例化Animal对象
        System.out.println("Animal a1 = new Dog()：" + (a1 instanceof Animal));
        System.out.println("Animal a1 = new Dog()：" + (a1 instanceof Dog));
        Animal a2 = new Animal();     // 实例化Animal对象
        System.out.println("Animal a2 = new Animal()：" + (a2 instanceof Animal));
        System.out.println("Animal a2 = new Animal()：" + (a2 instanceof Dog));
    }
}

 */

/*
// 定义Animal类
class Animal {
    // 定义动物叫的方法
    void shout() {
        System.out.println("动物叫！");
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args)  {
        Animal animal = new Animal();  	         // 创建Animal类对象
        System.out.println(animal.toString());	 // 调用toString()方法并打印
    }
}

 */

/*
// 定义Animal类
class Animal {
    //重写Object类的toString()方法
    public String toString(){
        return "这是一个动物。";
    }
}
// 定义测试类
public class Summary01 {
    public static void main(String[] args) {
        Animal animal = new Animal(); 			// 创建animal对象
        System.out.println(animal.toString()); // 调用toString()方法并打印
    }
}

 */

/*
class Outer {
    int m = 0;                        // 定义类的成员变量

    //外部类方法test1()
    void test1() {
        System.out.println("外部类成员方法test1()");
    }

    //外部类方法test2()
    void test2() {
        Inner inner = new Inner();                         //实例化内部类对象inner
        System.out.println("内部成员变量n = " + inner.n); //访问内部类变量和方法
        inner.show2();
    }

    // 下面的代码定义了一个成员内部类Inner
    class Inner {
        int n = 1;

        void show1() {
            // 在成员内部类的方法中访问外部类的成员变量m
            System.out.println("外部成员变量m = " + m);
            // 在成员内部类的方法中访问外部类的成员方法test1()
            test1();
        }

        void show2() {
            System.out.println("内部成员方法show2()");
        }
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Outer outer = new Outer();                //实例化外部类对象outer
        Outer.Inner inner = outer.new Inner();    //实例化内部类对象inner
        inner.show1();         //在内部类中访问外部类的成员变量m和成员方法test1()
        outer.test2();         //在内部类中访问内部类的成员变量n和成员方法show2()
    }
}

 */

/*
class Outer {
    int m = 0;                    // 定义类的成员变量

    //定义一个成员方法test1()
    void test1() {
        System.out.println("外部类成员方法test1()");
    }

    void test2() {
        //定义一个局部内部类，在局部内部类中访问外部类变量和方法
        class Inner {
            int n = 1;

            void show() {
                System.out.println("外部类成员变量m = " + m);
                test1();
            }
        }
        //访问局部内部类中的变量和方法
        Inner inner = new Inner();
        System.out.println("局部内部类变量n = " + inner.n);
        inner.show();
    }
}

public class Summary01 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.test2();     //通过外部类对象outer调用创建了局部内部类的方法test2()
    }
}

 */


/*
class Outer {
    static int m = 0; // 定义类的静态变量
    // 下面的代码定义了一个静态内部类
    static class Inner {
        int n = 1;
        void show() {
            // 在静态内部类的方法中访问外部类的静态变量m
            System.out.println("外部类静态变量m = " + m);
        }
    }
}
public class Summary01 {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

 */

/*
interface Animal {                    //定义接口Animal
    void shout();                    //定义抽象方法shout()
}

public class Summary01 {
    public static void main(String[] args) {
        String name = "小花";
        animalShout(new Animal() {    //调用animalShout()方法，参数为匿名内部类
            @Override
            public void shout() {
                System.out.println(name + "喵喵……");
            }
        });
    }

    public static void animalShout(Animal an) {    //该方法参数为Animal接口类型
        an.shout();
    }
}

 */


//	代码规范
//
//            （1）包名中所有字母小写
//
//            （2）类名和接口名的每个首字母都大写，ArrayList
//
//            （3）常量名中所有字母都大写，单词之间用下画线连接，DAY_OF_MONTH
//
//            （4）变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母大写，lineNumber，getLineNumber
//
//            （5）在程序中，尽量使用有意义的英文单词定义标识符，使程序便于阅读，userName定义用户，password定义密码
